home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / XML_CSSML / CSSML.php
Encoding:
PHP Script  |  2004-03-24  |  9.4 KB  |  317 lines
  1. <?php
  2. // {{{ license
  3.  
  4. // +----------------------------------------------------------------------+
  5. // | PHP version 4.0                                                      |
  6. // +----------------------------------------------------------------------+
  7. // | Copyright (c) 1997-2002 The PHP Group                                |
  8. // +----------------------------------------------------------------------+
  9. // | This source file is subject to version 2.0 of the PHP license,       |
  10. // | that is bundled with this package in the file LICENSE, and is        |
  11. // | available at through the world-wide-web at                           |
  12. // | http://www.php.net/license/2_02.txt.                                 |
  13. // | If you did not receive a copy of the PHP license and are unable to   |
  14. // | obtain it through the world-wide-web, please send a note to          |
  15. // | license@php.net so we can mail you a copy immediately.               |
  16. // +----------------------------------------------------------------------+
  17. // | Authors: Dan Allen <dan@mojavelinux.com>                             |
  18. // +----------------------------------------------------------------------+
  19.  
  20. // $Id: CSSML.php,v 1.4 2002/05/20 22:05:30 dallen Exp $
  21.  
  22. // }}}
  23. // {{{ description
  24.  
  25. // XML_CSSML is a CSSML to CSS xslt parser
  26.  
  27. // }}}
  28. // {{{ error codes
  29.  
  30. define('XML_CSSML_OK',                 0);
  31. define('XML_CSSML_ERROR',             -1);
  32. define('XML_CSSML_ALREADY_EXISTS',    -2);
  33. define('XML_CSSML_NOT_LOADED',        -3);
  34. define('XML_CSSML_INVALID_DATA',      -4);
  35. define('XML_CSSML_INVALID_DOCUMENT',  -5);
  36. define('XML_CSSML_INVALID_FILE',      -6);
  37.  
  38. // }}}
  39. // {{{ includes
  40.  
  41. require_once 'PEAR.php';
  42. require_once 'CSSML/error.php';
  43.  
  44. // }}}
  45. // {{{ functions
  46.  
  47. if (!function_exists('is_a')) {
  48.     function is_a($in_data, $in_detect)
  49.     {
  50.         return (bool) (is_object($in_data) && (get_class($in_data) == strtolower($in_detect) || is_subclass_of($in_data, strtolower($in_detect))));
  51.     }
  52. }
  53.  
  54. // }}}
  55.  
  56. // {{{ class XML_CSSML
  57.  
  58. /**
  59.  * The XML_CSSML class provides the xsl functions
  60.  * to parse a CSSML document into a stylesheet
  61.  * with the ability to output to a file or return
  62.  *
  63.  * @author   Dan Allen <dan@mojavelinux.com>
  64.  * @version  Revision: 0.1
  65.  * @access   public
  66.  * @package  XML_CSSML
  67.  */
  68.  
  69. // }}}
  70. class XML_CSSML {
  71.     // {{{ properties
  72.  
  73.     /**
  74.      * domxml object which holds the xml document with the css information
  75.      * @var object $CSSMLDoc
  76.      */
  77.     var $CSSMLDoc;
  78.  
  79.     /**
  80.      * domxml object which holds the xsl document which parses the cssml document
  81.      * @var object $stylesheetDoc
  82.      */
  83.     var $stylesheetDoc;
  84.  
  85.     /**
  86.      * Redirection method for the output of the cssml (file, stout)
  87.      * If redirection is a file, it must be absolute
  88.      * @var string $outputMethod
  89.      */
  90.     var $output = 'STDOUT';
  91.  
  92.     /**
  93.      * Code corresponding to the user agent of the browser,
  94.      * such as is generated with Net_UserAgentDetect
  95.      * @var string $browser
  96.      */
  97.     var $browser = '';
  98.  
  99.     /**
  100.      * Filter for the entries in the CSSML
  101.      * @var string $filter
  102.      */
  103.     var $filter = '';
  104.  
  105.     /**
  106.      * Comment to be used at the top of the stylesheet output
  107.      * @var string $comment
  108.      */
  109.     var $comment = '';
  110.  
  111.     /**
  112.      * Boolean which defines if the CSSML document has been loaded
  113.      * @var boolean $loaded
  114.      */
  115.     var $loaded = false;
  116.  
  117.     // }}}
  118.     // {{{ constructor
  119.  
  120.     /**
  121.      * Class constructor, prepare the cssml document object from either a string, file or object
  122.      *
  123.      * @param mixed $in_cssml Optionally the CSSML data can be passed to the constructor
  124.      * @return void
  125.      * @access private
  126.      */
  127.     function XML_CSSML($in_driver, $in_CSSML = null, $in_type = 'string', $in_params = null)
  128.     {
  129.         $this = $this->factory($in_driver, $in_CSSML, $in_type, $in_params);
  130.     }
  131.         
  132.     // }}}
  133.     // {{{ factory()
  134.  
  135.     function &factory($in_driver, $in_CSSML = null, $in_type = 'string', $in_params = null)
  136.     {
  137.         $interface_path = 'CSSML/' . $in_driver . '.php';
  138.         $interface_class = 'XML_CSSML_' . $in_driver;
  139.         
  140.         @include_once $interface_path;
  141.         
  142.         return new $interface_class($in_CSSML, $in_type, $in_params);
  143.     }
  144.  
  145.     // }}}
  146.     // {{{ load()
  147.  
  148.     /**
  149.      * Prepare the CSSML document object from either a string, file or object.  This
  150.      * will set the CSSMLDoc class variable which will be parsed by the xsl stylesheet
  151.      * into a CSS stylesheet
  152.      *
  153.      * @param mixed $in_CSSML The CSSML document which contains the information for
  154.      *                         generating the CSS document
  155.      *
  156.      * @return void
  157.      * 
  158.      */
  159.     function load()
  160.     {
  161.         if ($this->loaded) {
  162.             return PEAR::raiseError(null, XML_CSSML_ALREADY_EXISTS, null, E_USER_WARNING, $this->CSSMLDoc, 'XML_CSSML_Error', true);
  163.         }
  164.     }
  165.      
  166.      // }}}
  167.      // {{{ setParams()
  168.  
  169.     /**
  170.      * Set the params (params) that will be used when calling the stylesheet parser.
  171.      * This pertains particularly to variables such as browser code, image path and 
  172.      * the filter.  It works by passing an associative array with any number of the
  173.      * possible parameters for the stylesheet.  If a variable is not set, the default
  174.      * will be used
  175.      *
  176.      * @param array $in_params Associative array of the params
  177.      *
  178.      * @return void
  179.      * 
  180.      */
  181.     function setParams($in_params)
  182.     {
  183.         if (isset($in_params['browser'])) {
  184.             $this->browser = $in_params['browser']; 
  185.         }
  186.  
  187.         if (isset($in_params['filter'])) {
  188.             $this->filter = $in_params['filter'];
  189.         }
  190.  
  191.         if (isset($in_params['comment'])) {
  192.             $this->comment = str_replace(array('/*', '*/'), '', $in_params['comment']);
  193.         }
  194.  
  195.         if (isset($in_params['output'])) {
  196.             $this->output = $in_params['output'];
  197.             if ($in_params['output'] != 'STDOUT') {
  198.                 // check to make sure this is a file...this needs work
  199.                 if (!@file_exists($in_params['output']) && !@touch($in_params['output'])) {
  200.                     $this->output = 'STDOUT';
  201.                     return PEAR::raiseError(null, XML_CSSML_INVALID_FILE, PEAR_ERROR_PRINT, E_USER_NOTICE, '', 'XML_CSSML_Error', true);
  202.                 }
  203.             }
  204.         }
  205.     }
  206.  
  207.     // }}}
  208.     // {{{ process()
  209.  
  210.     /**
  211.      * Run the transformation on the CSSML document using the CSSML xsl stylesheet.  If
  212.      * the output method is to a file, then the function will not return.  If the output
  213.      * is set to STDOUT, the xml string will be returned (really the css document) after
  214.      * some clean up of entities and domxml bugs have been fixed
  215.      *
  216.      * @return css string if output method is STDOUT, else void
  217.      * @access public
  218.      */
  219.     function process() 
  220.     {
  221.         if (!$this->loaded) {
  222.             return PEAR::raiseError(null, XML_CSSML_NOT_LOADED, null, E_USER_WARNING, 'use load() function', 'XML_CSSML_Error', true);
  223.         }
  224.     }
  225.  
  226.     // }}}
  227.     // {{{ isError()
  228.  
  229.     /**
  230.      * Tell whether a result code from a XML_CSSML method is an error.
  231.      *
  232.      * @param  object  $in_value object in question
  233.      *
  234.      * @access public
  235.      * @return boolean whether object is an error object
  236.      */
  237.     function isError($in_value)
  238.     {
  239.         return is_a($in_value, 'xml_cssml_error');
  240.     }
  241.  
  242.     // }}}
  243.     // {{{ errorMessage()
  244.  
  245.     /**
  246.      * Return a textual error message for an XML_CSSML error code.
  247.      *
  248.      * @param  int $in_value error code
  249.      *
  250.      * @access public
  251.      * @return string error message, or false if not error code
  252.      */
  253.     function errorMessage($in_value) 
  254.     {
  255.         // make the variable static so that it only has to do the defining on the first call
  256.         static $errorMessages;
  257.  
  258.         // define the varies error messages
  259.         if (!isset($errorMessages)) {
  260.             $errorMessages = array(
  261.                 XML_CSSML_OK                    => 'no error',
  262.                 XML_CSSML_ERROR                 => 'unknown error',
  263.                 XML_CSSML_ALREADY_EXISTS        => 'cssml document already loaded',
  264.                 XML_CSSML_NOT_LOADED            => 'cssml document has not been loaded',
  265.                 XML_CSSML_INVALID_DATA          => 'invalid cssml data to parse',
  266.                 XML_CSSML_INVALID_DOCUMENT      => 'cssml domdocument could not be created',
  267.                 XML_CSSML_INVALID_FILE          => 'output file does not exist',
  268.             );  
  269.         }
  270.  
  271.         // If this is an error object, then grab the corresponding error code
  272.         if (XML_CSSML::isError($in_value)) {
  273.             $in_value = $in_value->getCode();
  274.         }
  275.         
  276.         // return the textual error message corresponding to the code
  277.         return isset($errorMessages[$in_value]) ? $errorMessages[$in_value] : $errorMessages[XML_CSSML_ERROR];
  278.     }
  279.  
  280.     // }}}
  281.     // {{{ reset()
  282.  
  283.     /**
  284.      * Resets the object so it is possible to load another xml document.
  285.      *
  286.      * @access public
  287.      * @return void
  288.      */
  289.     function reset()
  290.     {
  291.         $this->CSSMLDoc = null;
  292.         $this->loaded = false;
  293.     }
  294.  
  295.     // }}}
  296.     // {{{ free()
  297.  
  298.     /**
  299.      * Kill the class object to free memory.  Not really sure how necessary this is, but xml
  300.      * documents can be pretty big.  This will kill everything, so only use it when you are done
  301.      *
  302.      * @access public
  303.      * @return void
  304.      */
  305.     function free()
  306.     {
  307.         $vars = get_class_vars('XML_CSSML');
  308.  
  309.         foreach($vars as $var => $value) {
  310.             $this->$var = null;
  311.         }
  312.     }
  313.  
  314.     // }}}
  315. }
  316. ?>
  317.